/*
 * UtilRepresentacion.java	 
 *
 * Copyright 2008 Universidad Francisco de Paula Santander (UFPS).
 * Todos los Derechos Reservados.
 * Creado el 01/05/10, 07:29:38 PM
 */

package com.ufps.cuatro.modelo.representacion;

import com.ufps.cuatro.controlador.render.UtilRender;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.table.TableModel;

import com.ufps.cuatro.modelo.analizador.ObjetoReflexion;
import com.ufps.cuatro.modelo.biblioteca.BibliotecaTrabajo;
import com.ufps.cuatro.modelo.biblioteca.TipoBiblioteca;
import com.ufps.cuatro.modelo.codificacion.PaqueteClass;
import com.ufps.cuatro.modelo.representacion.componente.Componente;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidor;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorContenedorLibre;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorExtra;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorString;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorUnitario;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteGeneradoInterno;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteGeneradoSimple;
import com.ufps.cuatro.util.Representacion;
import com.ufps.cuatro.util.TipoCaso;
import com.ufps.cuatro.util.Utileria;
import com.ufps.cuatro.util.base.TipoDatoRepresentacionBase;
import com.ufps.cuatro.util.generadores.GeneradorComponentes;


/**
 * <i><b>UtilRepresentacion:</b></i> Clase de Recursos generales el cual brinda
 * soporte para el paquete.
 *
 * @author  Carlos A. Torres C. - Dolly E. Guerrero. <https://code.google.com/p/tesis4dor/>
 * @version 1.0 01/05/10
 */
public abstract class UtilRepresentacion {
    
    public final static int PROPIEDADES_CONSTRUCTORES = 0;
    public final static int PROPIEDADES_ATRIBUTOS = 1;
    public final static int PROPIEDADES_METODOS_ENTRADA = 2;
    public final static int PROPIEDADES_METODOS_SALIDA = 3;

    /**
     * @DefinicionAtributo
     */
    public static ArrayList<ObjetoTipoDatoReflexion> objTypesData;
    /**
     * @DefinicionAtributo
     */
    public static BibliotecaTrabajo objBibliotecaTrabajoLocal;
    /**
     * @DefinicionAtributo
     */
    public static BibliotecaTrabajo objBibliotecaTrabajoGlobal;
    /**
     * @DefinicionAtributo
     */
    public static BibliotecaTrabajo objBibliotecaTrabajoSwap;
    
    /**
     * @DefinicionAtributo
     */
    public static String strPathExportBiblioteca = "";
    /**
     * @DefinicionAtributo
     */
    public static String strPathBibliotecaGlobal;    
    public static String strPackageRootGUI;
    public static String strPackageRootGUIBeans;
    public static PaqueteClass objPaqueteRoot;

    static{
        try{
            init();            
        }catch(java.lang.Exception ex){
            Logger.getLogger(UtilRepresentacion.class.getName()).log(Level.SEVERE, null, ex);
        }        
    }
    
    private static void init(){        
        strPathBibliotecaGlobal = Utileria.strPathApp + "CuatroLib.4lib";
        strPackageRootGUI = Utileria.leerRecursoTexto("Utileria.constante.paquete.root.gui");
        strPackageRootGUIBeans = Utileria.leerRecursoTexto("Utileria.constante.paquete.root.gui.beans");
        objTypesData = new ArrayList<ObjetoTipoDatoReflexion>();  
        objPaqueteRoot = new PaqueteClass(UtilRepresentacion.strPackageRootGUI);
        objBibliotecaTrabajoLocal = new BibliotecaTrabajo(TipoBiblioteca.eLocal);
        objBibliotecaTrabajoGlobal = new BibliotecaTrabajo(TipoBiblioteca.eGlobal);
        objBibliotecaTrabajoSwap = new BibliotecaTrabajo(TipoBiblioteca.eSwap);        
    }
    
    public static void sort(List list){
        try{
            Collections.sort(list);
        }catch(java.lang.NullPointerException ex){
            System.out.println("Colección Nula.");
        }        
    }
    
//    public static boolean ant(){        
//        File buildFile = new File( Utileria.strPathUser, "build.xml");        
//        Project p = new Project(); 
//        p.setUserProperty("ant.file", buildFile.getAbsolutePath()); 
//        p.init(); 
//        ProjectHelper helper = ProjectHelper.getProjectHelper(); 
//        p.addReference("ant.projectHelper", helper); 
//        helper.parse(p, buildFile); 
//        p.executeTarget(p.getDefaultTarget()); 
//        
//        
//        return false;
//    }

    /**
     * @DefinicionMetodo
     * @param strClassPath @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean procesarClass(String strClassPath){
        try {
            //se obtiene la clase
            Class<?> objClass = Class.forName(strClassPath);
            if(!objClass.isEnum()){                
                procesarAtributos(objClass);
                procesarMetodos(objClass);
            }
            ObjetoTipoDatoReflexion objNuevoTipoDato = new ObjetoTipoDatoReflexion(objClass);
            if(java.lang.reflect.Modifier.isAbstract(objClass.getModifiers())){
                objNuevoTipoDato.setAbstractClass(true);                
            }
            objNuevoTipoDato.setContieneRepresentacionesGenericas(UtilRepresentacion.isIntoTipoGeneric(objNuevoTipoDato));
            objNuevoTipoDato.getObjCaso().setCollection(objNuevoTipoDato.contieneRepresentacionesGenericas());
            if(!UtilRepresentacion.objTypesData.contains(objNuevoTipoDato)){
                UtilRepresentacion.objTypesData.add(objNuevoTipoDato);
            }
            return true;
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(UtilRepresentacion.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
    
    /**
     * Devuelve el estado que indica si el tipo de dato puede contener tipos genericos.
     * @param objNuevoTipoDato
     * @return
     */
    public static boolean isIntoTipoGeneric(ObjetoTipoDatoReflexion objNuevoTipoDato){
       if(objNuevoTipoDato != null){
            TipoDatoRepresentacionBase objTipoDatoRepresentacionBase = GeneradorComponentes.devolverTipoDatoRepresentacionBasePorTipoDato(objNuevoTipoDato);        
            return objTipoDatoRepresentacionBase != null ? objTipoDatoRepresentacionBase.isCollectionObject() : false;
        }else{
            UtilRender.printlnConsole("Objeto nuevo tipo dato Nulo.", UtilRender.ACTION_NORMAL, false);
            return true;
        }
    }
    
    /**
     * @param objClass 
     * @DefinicionMetodo
@DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean procesarClass(Class<?> objClass){                    
        try{
            if(!objClass.isEnum()){
                procesarAtributos(objClass);
                procesarMetodos(objClass);
            }
            ObjetoTipoDatoReflexion objNuevoTipoDato = new ObjetoTipoDatoReflexion(objClass);
            objNuevoTipoDato.setContieneRepresentacionesGenericas(UtilRepresentacion.isIntoTipoGeneric(objNuevoTipoDato));
            objNuevoTipoDato.getObjCaso().setCollection(objNuevoTipoDato.contieneRepresentacionesGenericas());
            if(!UtilRepresentacion.objTypesData.contains(objNuevoTipoDato)){
                UtilRepresentacion.objTypesData.add(objNuevoTipoDato);
            }

            return true;        
        }catch(java.lang.NullPointerException ex){}
        return false;
    }
    
    private static ArrayList<ObjetoTipoDatoReflexion> procesarTipoGenerico(Type objGenericType) {        
        if(objGenericType instanceof ParameterizedType){
            ArrayList<ObjetoTipoDatoReflexion> objTiposGenericos = new ArrayList<ObjetoTipoDatoReflexion>();
            ParameterizedType objParameterizedType = (ParameterizedType) objGenericType;
            Type objTypeRaw = objParameterizedType.getRawType();           
            Class objClass  = (Class) objTypeRaw;
            String strClassPath = objClass.getCanonicalName();
            if(!strClassPath.equals("java.lang.Class")){
                Type[] objTypes = objParameterizedType.getActualTypeArguments();
                for(Type objType : objTypes){
                    Class objClassType = (Class) objType;
                    //se evalua que el tipo no haya sido agregado anteriormente
                    if(!isExisteTipoDato(objClassType)){//no se ha creado aun
                        procesarClass(objClassType);
                        ObjetoTipoDatoReflexion objNuevoTipoGenerico = new ObjetoTipoDatoReflexion(objClassType);
                        objNuevoTipoGenerico.setContieneRepresentacionesGenericas(UtilRepresentacion.isIntoTipoGeneric(objNuevoTipoGenerico));
                        objNuevoTipoGenerico.getObjCaso().setCollection(objNuevoTipoGenerico.contieneRepresentacionesGenericas());
                        objTiposGenericos.add(objNuevoTipoGenerico);                        
                    }
                    else{//crear una referencia
                        ObjetoTipoDatoReflexion objTipoGenericoExistente = getTipoDatoReflexionToClass(objClassType);
                        objTiposGenericos.add(objTipoGenericoExistente);
                    }
                } 
                return objTiposGenericos;
            }            
        }
        return null;
    }    

    private static void procesarAtributos(Class<?> objParentClass){
        for(Field objAtributo : objParentClass.getFields()){
            procesarAtributo(objAtributo);
        }
    }
    
    private static void procesarAtributo(Field objAtributo){
        Class objType = objAtributo.getType();
        Type objTypeGeneric = objAtributo.getGenericType();
        if(objType.isArray()){
            procesarArrayPropiedad(objType, objTypeGeneric);
        }
        else {
            procesarPropiedad(objType, objTypeGeneric);
        }                
    }
    
    private static ObjetoTipoDatoReflexion procesarPropiedad(Class<?> objType, Type objTypeGeneric){
        //Se Ignoran los Tipos de Datos void y Void del java.lang
        if(!objType.getSimpleName().equalsIgnoreCase("void")){
            ObjetoTipoDatoReflexion objNewType = new ObjetoTipoDatoReflexion(objType);
            objNewType.seteCaso(Representacion.esCaso(objType));
            ArrayList<ObjetoTipoDatoReflexion> objTiposGenericos = procesarTipoGenerico(objTypeGeneric);
            TipoDatoRepresentacionBase objTipoDatoRepresentacionBase = GeneradorComponentes.devolverTipoDatoRepresentacionBasePorClass(objType);
            if(objTipoDatoRepresentacionBase != null){
                objNewType.setColeccion(objTipoDatoRepresentacionBase.isCollectionObject());
            }        
            if(objTiposGenericos != null){
                objNewType.setContieneRepresentacionesGenericas(true);
                objNewType.getObjCaso().setCollection(true);
                objNewType.setObjTiposGenericos(objTiposGenericos);
            }
            if(!UtilRepresentacion.objTypesData.contains(objNewType)){                        
                UtilRepresentacion.objTypesData.add(objNewType);
                return objNewType;
            }
        }
        return null;
    }
    
    private static void procesarArrayPropiedad(Class<?> objArrayType, Type objTypeGeneric){
        ObjetoTipoDatoReflexion objNewArrayType = new ObjetoTipoDatoReflexion(objArrayType);
        ObjetoTipoDatoReflexion objTipoGet = UtilRepresentacion.procesarPropiedad(objArrayType.getComponentType(), objTypeGeneric);
        if(objTipoGet != null){
            objNewArrayType.setObjTipoIncluido(objTipoGet);
        }
        objNewArrayType.seteCaso(Representacion.esCaso(objArrayType));
        if(!UtilRepresentacion.objTypesData.contains(objNewArrayType)){                        
            ArrayList<ObjetoTipoDatoReflexion> objTiposGenericos = procesarTipoGenerico(objTypeGeneric);
            if(objTiposGenericos != null){
                objNewArrayType.setContieneRepresentacionesGenericas(true);
                objNewArrayType.getObjCaso().setCollection(true);
                objNewArrayType.setObjTiposGenericos(objTiposGenericos);
            }
            UtilRepresentacion.objTypesData.add(objNewArrayType);
        }        
    }
    
    private static void procesarMetodo(Method objMethod){
        procesarValorDeRetorno(objMethod);
        procesarParametros(objMethod);
    }
    
    private static void procesarValorDeRetorno(Method objMethod){
        Class objType = objMethod.getReturnType();
        Type objTypeGeneric = objMethod.getGenericReturnType();
        if(objType.isArray()){
            procesarArrayPropiedad(objType, objTypeGeneric);
        }
        else{
            procesarPropiedad(objType, objTypeGeneric);
        }  
        
    }
    
    private static void procesarParametros(Method objMethod){
        Class<?>[] objParametros = objMethod.getParameterTypes();
        Type[] objTypeParametros = objMethod.getGenericParameterTypes();
        for(int i = 0; i < objParametros.length; i++){
            Class<?> objParametro = objParametros[i]; 
            Type objType = objTypeParametros[i];
            if(objParametro.isArray()){
                procesarArrayPropiedad(objParametro, objType);
            }
            else{
                procesarPropiedad(objParametro, objType);
            }
        }
        
    }    

    private static void procesarMetodos(Class<?> objParentClass){
        for(Method objMethod : objParentClass.getMethods()){
            procesarMetodo(objMethod);
        }
    }

    /**
     * @DefinicionMetodo
     * @return @DefinicionReturn
     */
    public static ArrayList<ObjetoTipoDatoReflexion> getObjTypesData() {
        return objTypesData;
    }

    /**
     * @DefinicionMetodo
     * @param objTypesData @DefinicionParametro
     */
    public static void setObjTypesData(ArrayList<ObjetoTipoDatoReflexion> objTypesData) {
        UtilRepresentacion.objTypesData = objTypesData;
    }
    
    /**
     * @DefinicionMetodo
     * @param objPropiedad @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static ObjetoTipoDatoReflexion getTipoDatoReflexionToClass(Class<?> objPropiedad){
        try{
            for(ObjetoTipoDatoReflexion objTipoDato : UtilRepresentacion.objTypesData){
                if(objTipoDato.getStrClassPath().equals(objPropiedad.getCanonicalName())) {
                    return objTipoDato;
                }
            }
            return null;
        }catch(java.lang.NullPointerException ex){}
        return null;
    }
    
    /**
     * 
     * @param objPropiedad
     * @return
     */
    public static boolean isExisteTipoDato(Class<?> objPropiedad){
       try{
            for(ObjetoTipoDatoReflexion objTipoDato : UtilRepresentacion.objTypesData){
                if(objTipoDato.getStrClassPath().equals(objPropiedad.getCanonicalName())) {
                    return true;
                }
            }
            return false;
     }catch(java.lang.NullPointerException ex){}
       return false;
    }
    
    /**
     * @DefinicionMetodo
     * @param objMethod @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean isIs(Method objMethod){
      if(objMethod != null){
            boolean ok = false;
            for(String str : GeneradorComponentes.objAliasMetodosIs){
                if(objMethod.getName().startsWith(str)){
                    ok = true;
                    break;
                }
            }
            if(!ok)return false;
            if(objMethod.getParameterTypes().length != 0)   return false;  
            if(void.class.equals(objMethod.getReturnType())) return false;
            return true;
        }else{
            UtilRender.printlnConsole("Objeto metodo Nulo.", UtilRender.ACTION_NORMAL, false);
            return false;
        }
    }
    
    /**
     * @DefinicionMetodo
     * @param objMethod @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean isGetter(Method objMethod){
      if(objMethod != null){
            boolean ok = false;
            for(String str : GeneradorComponentes.objAliasMetodosGetter){
                if(objMethod.getName().startsWith(str)){
                    ok = true;
                    break;
                }
            }
            if(!ok)return false;
            if(objMethod.getParameterTypes().length != 0)   return false;  
            if(void.class.equals(objMethod.getReturnType())) return false;
            return true;
        }else{
            UtilRender.printlnConsole("Objeto Metodo Nulo.", UtilRender.ACTION_NORMAL, false); 
            return false;
        }
    }

    /**
     * @DefinicionMetodo
     * @param objMethod @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean isSetter(Method objMethod){
       if(objMethod != null){
            boolean ok = false;
            for(String str : GeneradorComponentes.objAliasMetodosSetter){
                if(objMethod.getName().startsWith(str)){
                    ok = true;
                    break;
                }
            }
            if(!ok)return false;
            if(objMethod.getParameterTypes().length != 1) return false;
            return true;
       }else{
            UtilRender.printlnConsole("Objeto Metodo Nulo.", UtilRender.ACTION_NORMAL, false); 
            return false;
        }
    }
    
    /**
     * @DefinicionMetodo
     * @param method @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean isRepresentacion(Method method){
       if(method != null){
            return isIs(method) || isGetter(method) || isSetter(method);
        }else{
            UtilRender.printlnConsole("Metodo Nulo.", UtilRender.ACTION_NORMAL, false); 
            return false;
        }
    }
    
    public static boolean isMetodoExcluido(Method method){
        try{
            String strMetodosExcluidos = Utileria.leerRecursoTexto("Utileria.exclusiones.metodos");
            String strMetodo = method.getName();
            return Utileria.evalInclusionInString(strMetodo, strMetodosExcluidos);        
        }catch(java.lang.NullPointerException ex){}
        return false;
    }
    
    public static boolean isPropiedadExcluida(String strPropiedad){
        try{
            String strPropiedadesExcluidos = Utileria.leerRecursoTexto("Utileria.exclusiones.codigo.propiedades");        
            return Utileria.evalInclusionInString(strPropiedad, strPropiedadesExcluidos);        
        }catch(java.lang.NullPointerException ex){}
        return false;
    }
    
    /**
     * @DefinicionMetodo
     * @param method @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static TipoMetodo eTipoMetodo(Method method){
        if(method != null){
            if(isGetter(method) || isIs(method)){
               return TipoMetodo.eGetter;	
            }    
            else if(isSetter(method)){
               return TipoMetodo.eSetter;	
            }    
            else if(method.getParameterTypes().length > 1 && 
                    !method.getReturnType().getClass().getCanonicalName().equals("void")) {
               return TipoMetodo.eProcessWithParamAndReturn;	
            }
            else if(method.getParameterTypes().length > 1 && 
                    method.getReturnType().getClass().getCanonicalName().equals("void")) {
               return TipoMetodo.eProcessWithParam;	
            }
            return TipoMetodo.eProcess;
        }else{
            UtilRender.printlnConsole("Metodo Nulo.", UtilRender.ACTION_NORMAL, false); 
            return null;
        }
    }
    
    /**
     * @DefinicionMetodo
     * @param objComponente @DefinicionParametro
     * @param objDistribucion @DefinicionParametro
     * @param manual @DefinicionParametro
     */
    public static void crearPlantillaIndependientes(ComponenteDistribuidorExtra objComponente, TableModel objDistribucion, boolean manual){        
        try{
        //se asume que aqui se adecuan las plantillas generadas o manulaes
        if(!manual){
            //el proceso es muy sencillo si el modo es automatico
            //se ausme que la distribucion de la mayoria de los componentes ha sido
            //generada por una plantilla preestablecida asi que solo se analizan los
            //componentes generados indpeendientes
            int filas = objDistribucion.getRowCount();
            int columnas = objDistribucion.getColumnCount();
            for(int i = 0; i < filas; i++){
                for(int j = 0; j < columnas; j++){
                    //se obtiene el nombre ingresado en la celda
                    String strCelda = (String) objDistribucion.getValueAt(j, i);
                    if(strCelda != null){
                        if(!strCelda.isEmpty()){
                            //se busca el posible componente
                            for(ComponenteGeneradoSimple objComponenteGenerado : objComponente.getObjComponentesGenerados()){
                                if(isEncontrado(objComponenteGenerado, strCelda)){
                                    //encuentra el Componente incluido ahora se determina
                                    //su independencia
                                    if(objComponenteGenerado.isIndependiente()){
                                        PlantillaComponente objPlantillaComponente = 
                                                GeneradorComponentes.crearPlantillaComponenteDefault(objComponenteGenerado);
                                        objPlantillaComponente.setX(j);
                                        objPlantillaComponente.setY(i);                                        
                                        //objComponenteGenerado.setObjPlantillaComponenteAutomatica(objPlantillaComponente);
                                        objPlantillaComponente.setIncluido(true);                                        
                                    }
                                }
                            }
                        }
                    }
                    
                }
            }
        }
        else{
            
        }
    }catch(java.lang.NullPointerException ex){}
        
    }
    
    /**
     * @DefinicionMetodo
     * @param objComponente @DefinicionParametro
     * @param objDistribucion @DefinicionParametro
     * @param manual @DefinicionParametro
     */
    public static void crearPlantillaIndependientes(ComponenteDistribuidorContenedorLibre objComponente, TableModel objDistribucion, boolean manual){        
        try{
            //se asume que aqui se adecuan las plantillas generadas o manulaes
            if(!manual){
                //el proceso es muy sencillo si el modo es automatico
                //se ausme que la distribucion de la mayoria de los componentes ha sido
                //generada por una plantilla preestablecida asi que solo se analizan los
                //componentes generados indpeendientes
                int filas = objDistribucion.getRowCount();
                int columnas = objDistribucion.getColumnCount();
                for(int i = 0; i < filas; i++){
                    for(int j = 0; j < columnas; j++){
                        //se obtiene el nombre ingresado en la celda
                        String strCelda = (String) objDistribucion.getValueAt(j, i);
                        if(strCelda != null){
                            if(!strCelda.isEmpty()){
                                //se busca el posible componente
                                for(ComponenteGeneradoSimple objComponenteGenerado : objComponente.getObjComponentesGenerados()){
                                    if(isEncontrado(objComponenteGenerado, strCelda)){
                                        //encuentra el Componente incluido ahora se determina
                                        //su independencia
                                        if(objComponenteGenerado.isIndependiente()){
                                            PlantillaComponente objPlantillaComponente = 
                                                    GeneradorComponentes.crearPlantillaComponenteDefault(objComponenteGenerado);
                                            objPlantillaComponente.setX(j);
                                            objPlantillaComponente.setY(i);                                        
                                            //objComponenteGenerado.setObjPlantillaComponenteGlobal(objPlantillaComponente);
                                            objPlantillaComponente.setIncluido(true);                                        
                                        }
                                    }
                                }
                            }
                        }

                    }
                }
            }
            else{

            }
        }catch(java.lang.NullPointerException ex){}
        
    }
    
    /**
     * @DefinicionMetodo
     * @param objComponente @DefinicionParametro
     * @param objDistribucion @DefinicionParametro
     */
    public static void crearPlantillaGlobales(ComponenteDistribuidorContenedorLibre objComponente, TableModel objDistribucion){        
       try{
        //se asume que aqui se adecuan las plantillas generadas o manulaes
        int filas = objDistribucion.getRowCount();
        int columnas = objDistribucion.getColumnCount();
        for(int i = 0; i < filas; i++){
            for(int j = 0; j < columnas; j++){
                //se obtiene el nombre ingresado en la celda
                String strCelda = (String) objDistribucion.getValueAt(j, i);
                if(strCelda != null){
                    if(!strCelda.isEmpty()){
                        //se busca el posible componente
                        for(Componente objComponenteExtra : objComponente.getObjComponentes()){
                            if(objComponenteExtra instanceof ComponenteDistribuidorExtra){
                                if(isEncontrado(objComponenteExtra, strCelda)){
                                    //encuentra el Componente incluido ahora se determina
                                    //su independencia                             
                                    PlantillaComponente objPlantillaComponente = 
                                            GeneradorComponentes.crearPlantillaComponenteDefault(objComponenteExtra);
                                    objPlantillaComponente.setX(j);
                                    objPlantillaComponente.setY(i);                                        
                                    //objComponenteExtra.setObjPlantillaComponenteGlobal(objPlantillaComponente);
                                    objPlantillaComponente.setIncluido(true);                                                                     
                                }
                            }
                        }
                    }
                }
            }
        }
    }catch(java.lang.NullPointerException ex){}
       
    }
    
    /**
     * @DefinicionMetodo
     * @param objComponente @DefinicionParametro
     * @param objDistribucion @DefinicionParametro
     */
    public static void crearPlantillaManual(ComponenteDistribuidorContenedorLibre objComponente, TableModel objDistribucion){        
       try{
        //se asume que aqui se adecuan las plantillas generadas o manulaes
        int filas = objDistribucion.getRowCount();
        int columnas = objDistribucion.getColumnCount();
        for(int i = 0; i < filas; i++){
            for(int j = 0; j < columnas; j++){
                //se obtiene el nombre ingresado en la celda
                String strCelda = (String) objDistribucion.getValueAt(j, i);
                if(strCelda != null){
                    if(!strCelda.isEmpty()){
                        //se busca el posible componente
                        for(Componente objComponenteExtra : objComponente.getObjComponentes()){
                            if(objComponenteExtra instanceof ComponenteDistribuidorExtra){
                                if(isEncontrado(objComponenteExtra, strCelda)){
                                    //encuentra el Componente incluido ahora se determina
                                    //su independencia                             
                                    PlantillaComponente objPlantillaComponente = 
                                            GeneradorComponentes.crearPlantillaComponenteDefault(objComponenteExtra);
                                    objPlantillaComponente.setX(j);
                                    objPlantillaComponente.setY(i);                                        
                                    //objComponenteExtra.setObjPlantillaComponenteGlobal(objPlantillaComponente);
                                    objPlantillaComponente.setIncluido(true);                                                                     
                                }
                            }
                        }
                    }
                }
            }
        }
    }catch(java.lang.NullPointerException ex){}
       
    }
    
    /**
     * @DefinicionMetodo
     * @param objComponente @DefinicionParametro
     * @param strName @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean isEncontrado(Componente objComponente, String strName){
        try{
            for(Propiedad objPropiedad : objComponente.getObjPropiedadesDisponibles()){
                if(objPropiedad.getObjParametroDefault(Propiedad.MODO_SET).getStrValue().equals(strName)){
                   return true;
                }
            }
            return false;
        }catch(java.lang.NullPointerException ex){}
        return false;
    }
    
    /**
     * @DefinicionMetodo
     * @return @DefinicionReturn
     */
    public static boolean isExistBibliotecaGlobal(){
        String strPathFile = UtilRepresentacion.strPathBibliotecaGlobal;
        try{
            File objFile = new File(strPathFile);
            return objFile.exists();
        }catch(java.lang.Exception ex){  
            Logger.getLogger(UtilRepresentacion.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    } 
    
    
    public static ArrayList<ObjetoTipoDatoReflexion> getColeccionTipoDatoReflexion(TipoCaso eCaso){
        if(eCaso != null){
            ArrayList<ObjetoTipoDatoReflexion> objTipos = new ArrayList<ObjetoTipoDatoReflexion>();
            for(ObjetoTipoDatoReflexion objTipoDato : UtilRepresentacion.objTypesData){
                if(objTipoDato.getObjCaso().geteCaso().equals(eCaso)){
                    objTipos.add(objTipoDato);
                }
            }
            return objTipos;
//        }catch(java.lang.NullPointerException ex){
//            System.out.println("Se ha recibido una Caso de Representación Nulo.");
        }
        else{
            UtilRender.printlnConsole("Tipo caso Nulo.", UtilRender.ACTION_NORMAL, false);            
        }
        return null;
    }
    
    public static boolean tieneModeloAsociadoAsignado(ComponenteDistribuidor objComponenteDistribuidor){
        if(objComponenteDistribuidor instanceof ComponenteDistribuidorExtra){
            ComponenteDistribuidorExtra objComponenteExtra = (ComponenteDistribuidorExtra) objComponenteDistribuidor;
            return objComponenteExtra.getObjModeloAsociado() != null;
        }
        else if(objComponenteDistribuidor instanceof ComponenteDistribuidorGeneradorUnitario){
            ComponenteDistribuidorGeneradorUnitario objComponenteGeneradorUnitario = (ComponenteDistribuidorGeneradorUnitario) objComponenteDistribuidor;
            return objComponenteGeneradorUnitario.getObjModeloAsociado() != null;
        }
        return false;
    }
    
    public static void visualizarEtiquetas(ArrayList<ComponenteDistribuidor> objComponentesGeneradoresParametros){
       try{ 
        for(ComponenteDistribuidor objComponenteDistribuidor : objComponentesGeneradoresParametros){
            if(objComponenteDistribuidor instanceof ComponenteDistribuidorGeneradorUnitario){
                ComponenteDistribuidorGeneradorUnitario objComponenteDistribuidorGeneradorUnitario = (ComponenteDistribuidorGeneradorUnitario) objComponenteDistribuidor;                        
                ComponenteGeneradoInterno objComponenteGeneradoInterno = objComponenteDistribuidorGeneradorUnitario.getObjComponenteGenerador();
                if(objComponenteGeneradoInterno.getObjClassSwing().getSimpleName().equals("JTextField")){
                    ComponenteGeneradoSimple objComponenteGeneradoSimple = objComponenteDistribuidorGeneradorUnitario.getObjComponentesGenerados().get(0);
                    Propiedad objPropiedad = GeneradorComponentes.getObjPropiedad(objComponenteGeneradoSimple, "Text");
                    ParametroPropiedad objParametro = objPropiedad.getObjParametroDefault(Propiedad.MODO_SET);
                    System.out.println(objParametro.getStrValue());
                }
            }                        
            else if(objComponenteDistribuidor instanceof ComponenteDistribuidorGeneradorString){
                ComponenteDistribuidorGeneradorString objComponenteDistribuidorGeneradorString = (ComponenteDistribuidorGeneradorString) objComponenteDistribuidor;                        
                ComponenteGeneradoInterno objComponenteGeneradoInterno = objComponenteDistribuidorGeneradorString.getObjComponenteGenerador();
                if(objComponenteGeneradoInterno.getObjClassSwing().getSimpleName().equals("JTextField")){
                    ComponenteGeneradoSimple objComponenteGeneradoSimple = objComponenteDistribuidorGeneradorString.getObjComponentesGenerados().get(0);
                    Propiedad objPropiedad = GeneradorComponentes.getObjPropiedad(objComponenteGeneradoSimple, "Text");
                    ParametroPropiedad objParametro = objPropiedad.getObjParametroDefault(Propiedad.MODO_SET);
                    System.out.println(objParametro.getStrValue());
                }
            }                        
        }           
        }catch(java.lang.NullPointerException ex){}
    }
    
    
    public static ArrayList<ObjetoTipoDatoReflexion> devolverTiposColeccionAnalizadas(){
        ArrayList<ObjetoTipoDatoReflexion> objColecciones = new ArrayList<ObjetoTipoDatoReflexion>();
        try{            
            for(ObjetoTipoDatoReflexion objTipoDato : UtilRepresentacion.objTypesData){
                if(objTipoDato.esColeccion()){
                    objColecciones.add(objTipoDato);
                }            
            }            
        }catch(java.lang.Exception ex){            
        }
        return objColecciones;
    }
    
    public static ArrayList<ObjetoTipoDatoReflexion> devolverTiposDatosFromArray(Class<?>[] parametros){
        try{
            ArrayList<ObjetoTipoDatoReflexion> objTiposDato = new ArrayList<ObjetoTipoDatoReflexion>();
            for(Class<?> objClass : parametros){
                ObjetoTipoDatoReflexion objTipoDatoParametro = GeneradorComponentes.devolverTipoDatoReflexionPorClass(objClass);
                objTiposDato.add(objTipoDatoParametro);
            }
            return objTiposDato;
        }catch(java.lang.NullPointerException ex){}
        return null;
    }
    
    public static ArrayList<ObjetoReflexion> devolverPropiedadesClase(Class<?> objClass, int modo, boolean not){                
        try{
        ArrayList<ObjetoReflexion> objPropiedadesReflexion = new ArrayList<ObjetoReflexion>();
        if(modo == UtilRepresentacion.PROPIEDADES_CONSTRUCTORES){
            Constructor<?>[] objArrayConstructores = objClass.getConstructors();
            for(Constructor<?> objConstructor : objArrayConstructores){                
                if(objConstructor.getParameterTypes().length > 0){
                    ObjetoReflexion objReflexionConstructor = new ObjetoReflexion(objConstructor);
                    objReflexionConstructor.setObjClass(objClass);
                    objPropiedadesReflexion.add(objReflexionConstructor);
                }
            }
        }
        else if(modo == UtilRepresentacion.PROPIEDADES_METODOS_SALIDA){
            Method[] objArrayMethods = objClass.getMethods();
            for(Method objMethod : objArrayMethods){                
                if((UtilRepresentacion.isGetter(objMethod) || UtilRepresentacion.isIs(objMethod)) && !UtilRepresentacion.isMetodoExcluido(objMethod)){                                                
                    Class<?> objClassTipoDato = objMethod.getReturnType();                        
                    if(UtilRepresentacion.objBibliotecaTrabajoLocal.existeComponenteGeneradorPorClass(objClassTipoDato)){
                        if(!not){
                            ObjetoReflexion objReflexionMethod = new ObjetoReflexion(objMethod);
                            objPropiedadesReflexion.add(objReflexionMethod);
                        }
                    }
                    else{
                        if(not){
                            ObjetoReflexion objReflexionMethod = new ObjetoReflexion(objMethod);
                            objPropiedadesReflexion.add(objReflexionMethod);
                        }
                    }
                }
            }
        }                
        else if(modo == UtilRepresentacion.PROPIEDADES_METODOS_ENTRADA){
            Method[] objArrayMethods = objClass.getMethods();
            for(Method objMethod : objArrayMethods){                
                if(UtilRepresentacion.isSetter(objMethod) && !UtilRepresentacion.isMetodoExcluido(objMethod)){                                                
                    Class<?> objClassTipoDato = objMethod.getParameterTypes()[0];
                    if(UtilRepresentacion.objBibliotecaTrabajoLocal.existeComponenteGeneradorPorClass(objClassTipoDato)){
                        if(!not){
                            ObjetoReflexion objReflexionMethod = new ObjetoReflexion(objMethod);
                            objPropiedadesReflexion.add(objReflexionMethod);
                        }
                    }
                    else{
                        if(not){
                            ObjetoReflexion objReflexionMethod = new ObjetoReflexion(objMethod);
                            objPropiedadesReflexion.add(objReflexionMethod);
                        }
                    }
                }
            }
        }   
        return objPropiedadesReflexion;
    }catch(java.lang.NullPointerException ex){}
        return null;
    }
    
    public static ObjetoReflexion crearObjetoReflexion(Method objMethod){
        try{
            ObjetoReflexion objReflexionMethod = new ObjetoReflexion(objMethod);
            return objReflexionMethod;
        }catch(java.lang.NullPointerException ex){}
        return null;
    }
    
    public static Method devolverToStringClass(Class<?> objClass){
        try{
            try {
                Method objMethod = objClass.getMethod("toString", (Class<?>[]) null);
                return objMethod;
            } catch (NoSuchMethodException ex) {
                Logger.getLogger(UtilRepresentacion.class.getName()).log(Level.SEVERE, null, ex);
            } catch (SecurityException ex) {
                Logger.getLogger(UtilRepresentacion.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
        }catch(java.lang.NullPointerException ex){}
        return null;
    }
    
    
}
